// 引入ASP.NET Core MVC控制器相关命名空间
using Microsoft.AspNetCore.Mvc;
// 引入项目中的数据传输对象
using Rabbit3.Api.Dto;
// 引入项目中的服务接口
using Rabbit3.Api.Services;
// 引入数据验证相关命名空间
using System.ComponentModel.DataAnnotations;

namespace Rabbit3.Api.Controllers
{
    /// <summary>
    /// 溯源管理控制器 - 负责处理食品溯源相关的HTTP请求
    /// 提供溯源信息的增删改查、完整度计算、溯源码导出等功能
    /// </summary>
    [ApiController] // 标识这是一个API控制器，自动处理模型验证和错误响应
    [Route("api/[controller]")] // 设置路由前缀为 api/Traceability
    public class TraceabilityController : ControllerBase
    {
        // 溯源服务接口，用于处理业务逻辑
        private readonly ITraceabilityService _traceabilityService;
        // 日志记录器，用于记录操作日志和错误信息
        private readonly ILogger<TraceabilityController> _logger;

        /// <summary>
        /// 构造函数 - 通过依赖注入初始化控制器
        /// </summary>
        /// <param name="traceabilityService">溯源服务实例</param>
        /// <param name="logger">日志记录器实例</param>
        public TraceabilityController(ITraceabilityService traceabilityService, ILogger<TraceabilityController> logger)
        {
            // 初始化溯源服务
            _traceabilityService = traceabilityService;
            // 初始化日志记录器
            _logger = logger;
        }

        /// <summary>
        /// 分页查询溯源信息 - 支持按条件筛选和分页显示
        /// </summary>
        /// <param name="queryDto">查询条件DTO，包含分页参数和筛选条件</param>
        /// <returns>分页结果，包含数据列表和分页信息</returns>
        [HttpGet("list")] // HTTP GET请求，路径为 api/Traceability/list
        public async Task<ActionResult<PagedResponseDto<TraceabilityResponseDto>>> GetPagedList([FromQuery] QueryTraceabilityDto queryDto)
        {
            try
            {
                // 调用服务层方法获取分页数据
                var result = await _traceabilityService.GetPagedListAsync(queryDto);
                // 返回200状态码和查询结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含异常详情
                _logger.LogError(ex, "查询溯源信息列表失败");
                // 返回500服务器内部错误
                return StatusCode(500, "查询失败");
            }
        }
        

        /// <summary>
        /// 根据ID获取单个溯源信息详情
        /// </summary>
        /// <param name="id">溯源信息ID</param>
        /// <returns>溯源信息详情，如果不存在返回404</returns>
        [HttpGet("{id}")] // HTTP GET请求，路径为 api/Traceability/{id}
        public async Task<ActionResult<TraceabilityResponseDto>> GetById(int id)
        {
            try
            {
                // 根据ID查询溯源信息
                var result = await _traceabilityService.GetByIdAsync(id);
                // 如果查询结果为空，返回404未找到
                if (result == null)
                {
                    return NotFound("未找到指定的溯源信息");
                }
                // 返回200状态码和查询结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "获取溯源信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, "获取失败");
            }
        }

        /// <summary>
        /// 创建新的溯源信息
        /// </summary>
        /// <param name="createDto">创建溯源信息的DTO对象</param>
        /// <returns>创建成功返回201状态码和新创建的溯源信息</returns>
        [HttpPost] // HTTP POST请求，路径为 api/Traceability
        public async Task<ActionResult<TraceabilityResponseDto>> Create([FromBody] CreateTraceabilityDto createDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层创建溯源信息
                var result = await _traceabilityService.CreateAsync(createDto);
                // 返回201创建成功状态码，并在Location头中返回新资源的URL
                return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
            }
            catch (Exception ex)
            {
                // 记录错误日志
                _logger.LogError(ex, "创建溯源信息失败");
                // 返回500服务器内部错误
                return StatusCode(500, "创建失败");
            }
        }

        /// <summary>
        /// 更新现有的溯源信息
        /// </summary>
        /// <param name="updateDto">包含更新数据的DTO对象</param>
        /// <returns>更新成功返回200状态码和更新后的溯源信息</returns>
        [HttpPut] // HTTP PUT请求，路径为 api/Traceability
        public async Task<ActionResult<TraceabilityResponseDto>> Update([FromBody] UpdateTraceabilityDto updateDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层更新溯源信息
                var result = await _traceabilityService.UpdateAsync(updateDto);
                // 如果更新失败（未找到记录），返回404未找到
                if (result == null)
                {
                    return NotFound("未找到指定的溯源信息");
                }
                // 返回200状态码和更新后的结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含更新DTO的ID
                _logger.LogError(ex, "更新溯源信息失败，ID: {Id}", updateDto.Id);
                // 返回500服务器内部错误
                return StatusCode(500, "更新失败");
            }
        }

        /// <summary>
        /// 软删除指定的溯源信息（逻辑删除，不物理删除）
        /// </summary>
        /// <param name="id">要删除的溯源信息ID</param>
        /// <returns>删除结果，包含成功/失败状态和消息</returns>
        [HttpDelete("{id}")] // HTTP DELETE请求，路径为 api/Traceability/{id}
        public async Task<ActionResult<object>> Delete(int id)
        {
            try
            {
                // 调用服务层执行软删除操作
                var result = await _traceabilityService.DeleteAsync(id);
                // 如果删除失败（未找到记录），返回404未找到
                if (!result)
                {
                    return NotFound(new { message = "未找到指定的溯源信息", success = false });
                }
                // 返回200状态码和成功消息
                return Ok(new { message = "删除成功", success = true });
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "删除溯源信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "删除失败", success = false });
            }
        }

        /// <summary>
        /// 批量软删除多个溯源信息（逻辑删除，不物理删除）
        /// </summary>
        /// <param name="ids">要删除的溯源信息ID列表</param>
        /// <returns>批量删除结果，包含成功/失败状态和消息</returns>
        [HttpDelete("batch")] // HTTP DELETE请求，路径为 api/Traceability/batch
        public async Task<ActionResult<object>> BatchDelete([FromBody] List<int> ids)
        {
            try
            {
                // 验证ID列表不能为空
                if (ids == null || !ids.Any())
                {
                    return BadRequest(new { message = "ID列表不能为空", success = false });
                }

                // 调用服务层执行批量软删除操作
                var result = await _traceabilityService.BatchDeleteAsync(ids);
                // 如果批量删除失败（未找到任何记录），返回404未找到
                if (!result)
                {
                    return NotFound(new { message = "未找到指定的溯源信息", success = false });
                }
                // 返回200状态码和成功消息
                return Ok(new { message = "批量删除成功", success = true });
            }
            catch (Exception ex)
            {
                // 记录错误日志
                _logger.LogError(ex, "批量删除溯源信息失败");
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "批量删除失败", success = false });
            }
        }

        /// <summary>
        /// 导出指定溯源信息的溯源码（用于生成二维码或条形码）
        /// </summary>
        /// <param name="id">溯源信息ID</param>
        /// <returns>溯源码字符串，如果不存在返回404</returns>
        [HttpGet("{id}/export-code")] // HTTP GET请求，路径为 api/Traceability/{id}/export-code
        public async Task<ActionResult<string>> ExportTraceabilityCode(int id)
        {
            try
            {
                // 调用服务层生成溯源码
                var result = await _traceabilityService.ExportTraceabilityCodeAsync(id);
                // 如果生成失败（未找到记录），返回404未找到
                if (result == null)
                {
                    return NotFound("未找到指定的溯源信息");
                }
                // 返回200状态码和溯源码
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "导出溯源码失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, "导出失败");
            }
        }

        /// <summary>
        /// 计算指定溯源信息的完整度百分比
        /// 完整度基于各个阶段信息的完整性：养殖、屠宰、深加工、企业信息、供应商信息
        /// </summary>
        /// <param name="id">溯源信息ID</param>
        /// <returns>完整度百分比（0-100），计算失败返回500错误</returns>
        [HttpGet("{id}/completeness")] // HTTP GET请求，路径为 api/Traceability/{id}/completeness
        public async Task<ActionResult<int>> CalculateCompleteness(int id)
        {
            try
            {
                // 调用服务层计算完整度
                var result = await _traceabilityService.CalculateCompletenessAsync(id);
                // 返回200状态码和完整度结果
                return Ok(new { completeness = result, message = "计算成功" });
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "计算溯源信息完整度失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "计算失败" });
            }
        }
    }
}
